//
// Created by Administrator on 2023/6/24.
/*
https://www.luogu.com.cn/problem/B3851
 2023 年 6 月 GESP C++ 四级编程第 2 题
题目描述

图像是由很多的像素点组成的。如果用0 表示黑，255 表示白，0 和 255 之间的值代表不同程度的灰色，则可以用一个字节表达一个像素（取值范围为十进制 0-255、十六进制 00-FF）。这样的像素组成的图像，称为 256 级灰阶的灰度 图像。

现在希望将 256 级灰阶的灰度图像压缩为 16 级灰阶，即每个像素的取值范围为十进制 0-15、十六进制 0-F。压缩规则为：统计出每种灰阶的数量，取数量最多的前 16 种灰阶（如某种灰阶的数量与另外一种灰阶的数量相同，则以灰阶值从小到大为序），分别编号 0-F（最多的编号为 0，以此类推）。其他灰阶转换到最近的 16 种灰阶之一，将某个点灰阶数与 16 种灰阶种的一种相减，绝对值最小即为最近，如果绝对值相等，则编号较小的灰阶更近。
输入格式

输入第 1 行为一个正整数 N，表示接下来有 N 行数据组成一副 256级灰阶的灰度图像。约定 10≤N≤20。

从第 2 行开始的 N 行，每行为长度相等且为偶数的字符串，每两个字符用十六进制表示一个像素。约定输入的灰度图像至少有 16 种灰阶。约定每行最多 20 个像素。
输出格式

第一行输出压缩选定的 16 种灰阶的十六进制编码，共计 32 个字符。

第二行开始的 N 行，输出压缩后的图像，每个像素一位十六进制数表示压缩后的灰阶值。
输入输出样例
输入 #1
10
00FFCFAB00FFAC09071B5CCFAB76
00AFCBAB11FFAB09981D34CFAF56
01BFCEAB00FFAC0907F25FCFBA65
10FBCBAB11FFAB09981DF4CFCA67
00FFCBFB00FFAC0907A25CCFFC76
00FFCBAB1CFFCB09FC1AC4CFCF67
01FCCBAB00FFAC0F071A54CFBA65
10EFCBAB11FFAB09981B34CFCF67
01FFCBAB00FFAC0F071054CFAC76
1000CBAB11FFAB0A981B84CFCF66
输出 #1
ABCFFF00CB09AC07101198011B6776FC
321032657CD10E
36409205ACC16D
B41032657FD16D
8F409205ACF14D
324F326570D1FE
3240C245FC411D
BF4032687CD16D
8F409205ACC11D
B240326878D16E
83409205ACE11D
说明/提示
灰阶 'AB'、'CF' 和 'FF' 出现 14 次，'00' 出现 10 次，'CB' 出现 9 次，'09' 出现 7 次，'AC' 出现 6 次，'07' 出现 5 次，'10'、'11' 和 '98' 出现 4 次，'01'、'1B'、'67'、'76' 和 'FC' 出现 3 次。

 * */
// 1. 去掉了string image[n]就通过测试了, 这个完全没用到还浪费内存--优化了这一项就通过了测试
// 2. 对压缩是判断间距优化, 去掉数组
//
#include <iostream>
#include <vector>
using namespace std;

// 十六进制的char转成十进制
int charToDec(char c)
{
    if (c>='0' && c<='9')
        return c-'0';
    else if (c>='A' && c<='F')
        return c-'A'+10;
    else if (c>='a' && c<='f')
        return c-'a'+10;
    else
        return -1;

}

// 计算x^y
int myPow(int x, int y)
{
    int ret = 1;
    while(y--)
        ret*=x;
    return ret;
}

// 用16进制表示的字符串转成整数
int hexStrToInt(string num)
{
    int length = num.size();
    int ret = 0;
    for (int i = 0; i < length; ++i)
    {
        ret += charToDec(num[i])*myPow(16,length-i-1);
    }
    return ret;
}

int main()
{
//    int a= 0x9f;
//    printf("%x\n",a-0x0f);
//    string x = "ffF";
//    printf("%d\n",hexStrToInt(x));
//    char b[] ={'b'};
//    string t=b;
    int n,length;
    cin>>n;
//    string image[n];
    int bucket[256]={0};
    vector<int> original={};
    // 将所有字符串两两截取, 存入桶中
    for (int i = 0; i < n; ++i)
    {
        string str;
        cin>>str;
        length=str.size();
        for (int j = 0; j < length; j+=2)
        {
//            char two[]={image[i][j],image[i][j+1]};
            string t = str.substr(j,2);
            int index = hexStrToInt(t);
            //  将原始数据两两一对转成整型 存入数组中
            original.push_back(index);
            bucket[index]++;
        }
    }
    // 打印桶中的数据
//    for (int i = 0; i < 256; ++i)
//    {
//        if (bucket[i])
//            printf("bucket[%02X]=%d\n",i,bucket[i]);
//
//    }
    char count=0;
    // 数据最多的16个像素值
    int zip[16]={0};
    for (int i = length/2*n; i >=0; i--)
    {
        for (int j = 0; j < 256; ++j)
        {
            if(bucket[j]==i)
            {
                printf("%02X",j);
                zip[count]=j;
                count++;
            }
            if (count>=16)
                break;
        }
        if (count>=16)
            break;
    }
    // 打印数据最多的16个像素值
//    cout<<endl;
//    for (int i = 0; i < 16; ++i)
//    {
//        cout<<endl<<zip[i]<<' ';
//        printf("%X: %02X ",i,zip[i]);
//    }
    // 打印原始图像数组
//    cout<<endl;
//    for (int i = 0; i < original.size(); ++i)
//    {
//        printf("%02X ",original[i]);
//        if ((i+1)%(length/2)==0)
//            cout<<endl;
//    }
    cout<<endl;
    // 压缩图像, 逐一比对原始数组每个元素与16个最多的像素值差距的绝对值
    // 建立16个元素的数组, 将每次计算的绝对值存进去,找最小的那个输出索引值
    for (int i = 0; i < original.size(); ++i)
    {
        int minElement=255,minIndex=0; // 最小值和最小值对应的索引
//        int temp[16]={0};
        for (int j = 0; j < 16; ++j)
        {
            int distance = abs(zip[j]-original[i]); // 计算差距的绝对值
            if (distance==0)
            {
//                printf("%X",j);
                minIndex=j;
//                minElement=0;
                break;
            }
            else
            {
//                temp[j]=distance;
                if (distance<minElement)
                {
                    minElement=distance;
                    minIndex=j;
                }
            }
        }
        printf("%X",minIndex);

        if ((i+1)%(length/2)==0)
            cout<<endl;
    }
    return 0;
}



